Methods and systems for monitoring contributor performance for source code programming projects

ABSTRACT

Methods and systems for monitoring contributor performance for source code programming projects in order to increase the velocity of workflow and the efficiency of project teams. In particular, the methods and systems record the particular type of issue that is tagged for a given contribution, if any, and monitor the amount of programming time of the contributor that is required to resolve the issue. The programming time required to resolve the issue, the type of issue, and/or other characteristics of contributors are then used to generate real-time recommendations related to the performance of the contributor relative to the project team.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.17/487,605, filed Sep. 28, 2021, which is a continuation of U.S. patentapplication Ser. No. 16/902,133, filed Jun. 15, 2020. The content of theforegoing application is incorporated herein in its entirety byreference.

FIELD OF THE INVENTION

The invention relates to monitoring contributor performance for sourcecode programming projects.

BACKGROUND

Computer programming is typically a team-based activity, in which theresponsibilities for the features and source code necessary to produce agiven project (e.g., a software application) are shared among teammembers. To facilitate this team activity, team members may submitcontributions to the project to a distributed version control system.This system may include a codebase that features a full history of theproject that is mirrored on every contributor's computer. The system mayenable automatic management of different branches of the project as wellas the merging of different contributions. The team may also utilize oneor more issue management and bug-tracking tools. The team may furtherout-source some issues to software-as-a-service providers. Accordingly,project management for computer programming often involves multiple teammembers and service providers sharing multiple versions, a singlecodebase for the project. As the single codebase is shared amongst teammembers, the performance of each team member must be monitored andassessed in order to maintain workflow velocity and prevent bottlenecks.

Furthermore, while responsibilities of each team member are oftenintertwined, the tasks of individual team members are distinct. Thedistinctness of each task makes determining the quality of thecontribution of each team member difficult. Even once a source codecontribution has been generated, the review of that code is both atime-consuming and subjective process. Thus, determining the quality ofan individual team member is often difficult. However, many tasks mustbe performed in series and must build on top of previously completedtasks. Contributions of poor quality, or poorly performing contributors,may therefore create bottlenecks that may stall a project. Accordingly,the inability to properly determine the performance of a contributorresults in a decrease in the velocity of workflow in the project andreduces efficiency of the project team overall.

To create further complications, as each team member may generatemultiple contributions each corresponding to a different task, and eventasks requiring different skills. The criteria for each of these tasksmay vary as well as the performance of the team member during each task.A team member's overall performance must therefore be based on multipletasks, perhaps across multiple projects and time periods, each requiringdistinct skills, with no baseline metric to measure performance on anindividual or aggregate level.

SUMMARY

Methods and systems are described herein for monitoring contributorperformance for source code programming projects in order to increasethe velocity of workflow and the efficiency of project teams. Asdescribed above, determining the quality of an individual contributor aswell as the quality of the contributor's work is often difficult. Themethods and systems described herein solve this problem by storingadditional information on specific metrics related to a contribution toa source code programming project. These metrics create quantitativeassessments for the contributor and the contributor's contribution.These metrics in turn can be used to generate unbiased andnon-subjective recommendations related to the contributor's performance.Additionally, the metrics are flexible and not tied to a particular taskor skill and may be scaled to reflect the contributor's performanceacross multiple projects and/or time periods.

For example, due to the nature of coding, different tasks may takedifferent amounts of time, and the dynamic nature of coding and softwaredevelopment projects prevents a standardization of the time required orthe way in which to complete tasks (e.g., what code to use), even withtasks that have similar criteria. Moreover, the stylistic differencesbetween coders may cause different coders to subjectively view acontribution more or less positively based on whether or not the stylereflects his/her own stylistic choices, even if the underlyingcontribution is functionally the same or better. Thus, conventionalsystems that focus on assessing the quality of the contribution, basedon the code itself, provide a biased and subjective analysis. Moreover,many software development control systems rely on software developmenttools through which contributions may be submitted that are not strictlybased on the code itself; thus, conventional systems are not able toassess these contributions.

In contrast, the methods and systems described herein assess the qualityof a contribution and/or contributor based on specifically selectedstandardized metrics that are determined through novel means. By usingthese metrics, contributors and project teams as a whole may receivereal-time feedback on contributor performance, from a variety ofsoftware development tools that is unbiased and non-subjective. Inparticular, the methods and systems as described herein record theparticular type of issue that is tagged for a given contribution, ifany, and monitor the amount of programming time of the contributor thatis required to resolve the issue. The programming time required toresolve the issue, the type of issue, and/or other characteristics ofcontributors are then used to generate real-time recommendations relatedto the performance of the contributor relative to the project team. Theuse of these specific non-conventional data points provide astandardized way to assess the quality of the contribution, which isbias free. Additionally, the use of these specific non-conventional datapoints allows for the system to normalize and interpret metrics that maybe received from a plurality of different software development tools.

Methods and systems are also described herein for generating qualitativegraphical representations of the standardized metrics. For example, inorder to allow contributors to intuitively understand and compare thestandardized metrics, the methods and systems convert the standardizedmetrics into graphical representations that allow for a qualitativecomparison of contributors. This conversion includes the retrieval ofthe standardized metrics and the use of non-conventional techniques forfiltering the metrics based on dynamic criteria to generate softwaredevelopment scores that may be used to compare different contributors.

Moreover, in order to generate the graphical representations in acomparative manner, in which different contributors may have differentauthorizations to access and/or review information about differentcontributors, the methods and systems recite the non-conventionaltechnique of filtering the data used to generate the graphicalrepresentations prior to generating the graphical representations asopposed to after. By doing so, the methods and systems, provide agraphical representation of a qualitative comparison of differentcontributors without creating additional privacy concerns.

In one aspect, the system may receive a first contribution of sourcecode for a first project to a software development version controlsystem, wherein the first contribution is received from a firstcontributor. The system may tag the first contribution with a firstidentified issue. The system may assign the first identified issue to asecond contributor. The system may receive a second contribution ofsource code to resolve the first identified issue. The system maydetermine a first resolution type of the second contribution. The systemmay determine a first length of programming time corresponding to thesecond contribution. The system may generate a first resolution metricfor the second contribution based on the first resolution type and thefirst length of programming time. The system may assign the firstresolution metric to the first contributor. The system may then generatefor display a first performance recommendation for the firstcontributor, wherein the first performance recommendation is based oncomparing the first resolution metric to a first plurality of resolutionmetrics assigned to other contributors of the first project.

In one aspect, the system may monitor contributions to softwaredevelopment version control systems for source code programmingprojects. For example, the system may receive a first softwaredevelopment score for a first contributor to a software developmentversion control system, wherein the first software development score isbased on a first plurality of weighted metrics. The system may store thefirst software development score with a plurality of other softwaredevelopment scores for other contributors. The system may receive afirst user input from the first contributor requesting access to thedatabase. The system may retrieve a user profile for the firstcontributor in response to receiving the first user input, wherein theuser profile includes a first authorization. The system may determine asubset of the plurality of other software development scores to whichthe first contributor has access based on the first authorization. Thesystem may generate for display, on a local device, a graphicalrepresentation of a qualitative comparison of the first softwaredevelopment score and the subset of the plurality of other softwaredevelopment scores.

Various other aspects, features, and advantages of the invention will beapparent through the detailed description of the invention and thedrawings attached hereto. It is also to be understood that both theforegoing general description and the following detailed description areexamples and not restrictive of the scope of the invention. As used inthe specification and in the claims, the singular forms of “a,” “an,”and “the” include plural referents unless the context clearly dictatesotherwise. In addition, as used in the specification and the claims, theterm “or” means “and/or” unless the context clearly dictates otherwise.Additionally, as used in the specification “a portion,” refers to a partof, or the entirety of (i.e., the entire portion), a given item (e.g.,data) unless the context clearly dictates otherwise.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows an illustrative user interface for a software developmentversion control system, in accordance with one or more embodiments.

FIG. 2 shows an illustrative system for a software development versioncontrol system, in accordance with one or more embodiments.

FIG. 3 shows a flowchart of the steps involved in generating for displaya first performance recommendation for the first contributor, inaccordance with one or more embodiments.

FIG. 4 shows a flowchart of the steps involved in determining aresolution metric, in accordance with one or more embodiments.

FIG. 5 shows flowchart of the steps involved in assigning issues tocontributors based on current performance levels of the contributors, inaccordance with one or more embodiments.

FIG. 6 shows an illustrative user interface displaying a graphicalrepresentation of a software development score, in accordance with oneor more embodiments.

FIG. 7 shows an illustrative user interface displaying a graphicalrepresentation of a software development score corresponding tocontribution categories, in accordance with one or more embodiments.

FIG. 8 shows an illustrative user interface displaying graphicalrepresentations of a plurality of software development scores forrespective users, in accordance with one or more embodiments.

FIG. 9 shows an illustrative user interface displaying graphicalrepresentation of a qualitative comparison of a first softwaredevelopment score and other software development scores, in accordancewith one or more embodiments.

FIG. 10 shows an illustrative pseudocode for generating softwaredevelopment scores, in accordance with one or more embodiments.

FIG. 11 shows a flowchart of the steps involved in generating fordisplay a graphical representation of a qualitative comparison of afirst software development score and a subset of the plurality of othersoftware development scores, in accordance with one or more embodiments.

FIG. 12 shows flowchart of the steps involved in calculating a softwaredevelopment score based on a plurality of weighted metrics, inaccordance with one or more embodiments.

DETAILED DESCRIPTION OF THE DRAWINGS

In the following description, for the purposes of explanation, numerousspecific details are set forth in order to provide a thoroughunderstanding of the embodiments of the invention. It will beappreciated, however, by those having skill in the art, that theembodiments of the invention may be practiced without these specificdetails or with an equivalent arrangement. In other cases, well-knownstructures and devices are shown in block diagram form in order to avoidunnecessarily obscuring the embodiments of the invention. It should alsobe noted that the methods and systems disclosed herein are also suitablefor applications unrelated to source code programming.

FIG. 1 shows an illustrative user interface for a software developmentversion control system, in accordance with one or more embodiments. Forexample, the system and methods described herein may generate fordisplay, on a local display device (e.g., user device 222 and 224 (FIG.2 ) described below), a first performance recommendation for a firstcontributor. The first performance recommendation may be based oncomparing a first resolution metric to a first plurality of resolutionmetrics assigned to other contributors of a first project.

As described herein, a performance recommendation may include anyquantitative or qualitative recommendation based on the performance ofthe contributor. The recommendation may be directed to the contributorthemselves and/or may be director to a project manager or othercontributors. In some embodiments, the system may further tailor therecommendation based on the determined audience of the recommendation.The performance recommendation may include one or more types ofinformation. For example, the performance recommendation may include anindividual (e.g., compare the contributor's current performance to ahistorical performance) or comparative analysis (e.g., compare thecontributor to other contributors) of the contributors. The performancerecommendation may be based on a performance level of the contributor(e.g., either historic or current) and/or the performance level of othercontributors (e.g., either historic or current). The performance levelmay include any quantitative or qualitative description of thecontributor's performance.

The performance level may itself be based on one or more resolutionmetrics. While resolution metrics may include any quantitative orqualitative description of a given contributor's performance withregards to a specific contribution, the resolution metric may be basedon multiple factors (e.g., as described below in relation to FIG. 4 ).In some embodiments, the system may determine resolution metrics basedon specific data that is generated in addition to a contributor's normalcontribution. This data may represent a quantitative assessment of theperformance of the contributor. Furthermore, to limit bias andsubjective input, the data may be normalized not to a specific task(e.g., how others performed on the specific task), but based on anassessment of the type and time to program a resolution to issuesdetected in the contributor's performance.

For example, FIG. 1 displays user interface 100. User interface 100 mayrepresent an exemplary user interface for software development versioncontrol system. As such, user interface 100 may include a plurality oftasks (e.g., task 104) that need to be completed for a project. Asdescribed herein, a project may include any individual or collaborativeenterprise that is carefully planned and designed to achieve aparticular aim. In some embodiments, the project may include a sourcecode programming or other project related to the development of softwareor a computer-based feature. The project may also include multiplecomponents or more of which may be based on programming source code,non-source code programming, and/or other development goals. Eachproject may include one or more contributors that submit contributionsto the goal of the project. For example, the project may include thedevelopment of a computer feature and/or the contributors to the projectmay be linked together through a common entity (e.g., a company) ororganized in a distributed fashion (e.g., a crowd-sourced project). Theproject may be distinguished from other projects based on a stated goal,time period, and/or the constituency of contributors.

In some embodiments, one or more contributions may correspond to one ormore projects and/or may further correspond to one or more softwaredevelopment tools. For example, the software development version controlsystem may receive contributions from one or more software developmenttools. Each software development tool may provide one or more good orservice that furthers a goal of the software development tool. Forexample, a software development tool may include a software-as-a-serviceprovider, that provides technical management support, such as IT servicemanagement, to the IT operations of large corporations, includingproviding help desk functionality. In another example, the softwaredevelopment tool may include a site that provide social networking-likefunctions such as feeds, followers, wikis and a social network graph todisplay how developers work on their versions (“forks”) of a repositoryand what fork (and branch within that fork) is newest. In anotherexample, the software development tool may include a service for hostingcode snippets for small and/or large projects. In another example, thesoftware development tool may include a service used for issue trackingand project management.

As presented in FIG. 1 , the plurality of tasks may be filtered based ona user selection requesting the display of completed tasks withidentified issues (e.g., identified through manual peer review, inaccordance with project procedures, and/or automatically through anissue-spotting or bug-tracking program). For example, a user (e.g., aproject manager and/or contributor) may filter the tasks by selecting anicon associated with tasks having issues (e.g., icon 102).

User interface may further include an icon featuring information about agiven issue (e.g., icons 106 and 108). For example, icons 106 and 108may indicate the type of issue, how the issue was detected (e.g., basedon manual or automatic review), and/or whether or not the issue isconfirmed to exist. User interface 100 may also include an iconindicating a second contributor that is assigned to resolve the issue(e.g., icon 110). As described below in relation to FIG. 5 , in someembodiments, the system may assign a second contributor to resolve theissue based on the respective performance levels of the contributors.

User interface 100 and the information displayed therein may begenerated using cloud-based memory configured to store current sourcecode for a first project and tags for identified issues in the currentsource code. For example, by storing current source code (e.g., acodebase) for the project and receiving contributions from multiplecontributors, the system may manage the creation of the source code forthe project while detecting and resolving issues in individualcontributions. Furthermore, by generating tags (e.g., metadatadescribing issues and information related to the issue such as thecontributor, type of task, how the issue was detected, etc.), the systemmay assign and resolve the identified issue through a means that allowsfor the creation of the resolution metric.

For example, the cloud-based control circuitry configured to receive afirst contribution of source code for a first project to a softwaredevelopment version control system, wherein the first contribution isreceived from a first contributor and tag the first contribution with afirst identified issue. The system may then assign the first identifiedissue to a second contributor and receive a second contribution ofsource code to resolve the first identified issue.

Additionally, the system may determine a first resolution type of thesecond contribution and determine a first length of programming timecorresponding to the second contribution. The information which relatesto the way in which the issue was resolve and the time that was requiredto resolve the issue is then used to generate a first resolution metricfor the second contribution based on the first resolution type and thefirst length of programming time, wherein the first resolution metric isgenerated using a machine learning model that compares the first lengthof programming time to a determined average length of programming timefor the first resolution type.

As used herein, a resolution type includes a quantitative or qualitativemetric used to distinguish one resolution type from another resolutiontype. For example, resolution type may be distinguished based on theunderlying problem such as erroneous code (e.g., unclosed loops,typographical errors, etc.), poor design (e.g., redundant functions,unnecessary links, etc.), or incorrect programming language and/or useof incorrect programming language functions. The resolution type mayalternatively or additionally be based on the complexity of theresolution. For example, the correction of a typographical error mayhave low complexity, whereas the re-writing of an entire sequence of thecontribution may have a high complexity. The resolution type mayalternatively or additionally be based on the skills of the contributorrequired to resolve the issue. For example, the correction of atypographical error may require only proofreading skills, whereas there-writing of an entire sequence of the contribution may requireproblem-solving and/or knowledge of the programming language.

The system may also track the amount of time required by the secondcontributor to correct the problem. In some embodiments, the system maytrack the entire length of time from assignment to resolution of theissue. Alternatively or additionally, the system may determine a lengthof programming time corresponding to a second contribution. For example,the length of programming time may correspond to the amount of time togenerate new code. In some embodiments, the system distinguishes lengthof time to generate the new code from the length of time (if any)required by the second contributor to identify the issue. For example,by distinguishing the total time in this way, the system may prevent theresolution metric from being biased by stylistic choices and/or otherfactors. The system may likewise determine a time the second contributoractually spent to resolve the issue (e.g., based on determining that thesecond contributor was active at his/her user device) in order toprevent the system from considering time when the second contributor wasaway from his/her user device (e.g., on a break).

The system may then generate and assign the first resolution metric. Insome embodiments, the system may track multiple contributors acrossmultiple projects and/or time periods and with references to thecurrent, determined and/or historical skills and performance level ofnumerous contributors. In some embodiments, the system may generatemachine learning models to determine resolution metrics, performancelevels, and/or performance recommendations.

In some embodiments, user interface 100 may also provide recommendationsfor staffing for future projects and/or tasks. For example, the systemmay monitor a software development score of a contributor (e.g., asdescribed in FIGS. 11-12 below). As the contributor, contributes to moreprojects and/or tasks, the system may update the software developmentscore of the contributor. For example, the system may receive an updatedfirst software development score for the first contributor, store theupdated first software development score, and generate for display agraphical representation of a relationship of the first softwaredevelopment score to the updated first software development score (e.g.,as shown in FIGS. 6-10 ). The system may further extrapolate a futurefirst software development score for the first contributor on a futureproject based on the first software development score and the updatedfirst software development score and generate for display arecommendation for staffing the future project based on the future firstsoftware development score. For example, the system may recommend agiven contributor for a given task and/or project in order to providethe most efficient and effective staffing.

FIG. 2 shows an illustrative system for a software development versioncontrol system, in accordance with one or more embodiments. As shown inFIG. 2 , system 200 may include user device 222, user device 224, and/orother components. Each user device may include any type of mobileterminal, fixed terminal, or other device. Each of these devices mayreceive content and data via input/output (hereinafter “I/O”) paths andmay also include processors and/or control circuitry to send and receivecommands, requests, and other suitable data using the I/O paths. Thecontrol circuitry may be comprised of any suitable processing circuitry.Each of these devices may also include a user input interface and/ordisplay for use in receiving and displaying data (e.g., user interface100 (FIG. 1 )). By way of example, user device 222 and user device 224may include a desktop computer, a server, or other client device. Usersmay, for instance, utilize one or more of the user devices to interactwith one another, one or more servers, or other components of system200. It should be noted that, while one or more operations are describedherein as being performed by particular components of system 200, thoseoperations may, in some embodiments, be performed by other components ofsystem 200. As an example, while one or more operations are describedherein as being performed by components of user device 222, thoseoperations may, in some embodiments, be performed by components of userdevice 224. System 200 also includes machine learning model 202, whichmay be implemented on user device 222 and user device 224, or accessibleby communication paths 228 and 230, respectively. It should be notedthat, although some embodiments are described herein with respect tomachine learning models, other prediction models (e.g., statisticalmodels or other analytics models) may be used in lieu of, or in additionto, machine learning models in other embodiments (e.g., a statisticalmodel replacing a machine learning model and a non-statistical modelreplacing a non-machine learning model in one or more embodiments).

Each of these devices may also include memory in the form of electronicstorage. The electronic storage may include non-transitory storage mediathat electronically stores information. The electronic storage of mediamay include (i) system storage that is provided integrally (e.g.,substantially non-removable) with servers or client devices and/or (ii)removable storage that is removably connectable to the servers or clientdevices via, for example, a port (e.g., a USB port, a firewire port,etc.) or a drive (e.g., a disk drive, etc.). The electronic storages mayinclude optically readable storage media (e.g., optical disks, etc.),magnetically readable storage media (e.g., magnetic tape, magnetic harddrive, floppy drive, etc.), electrical charge-based storage media (e.g.,EEPROM, RAM, etc.), solid-state storage media (e.g., flash drive, etc.),and/or other electronically readable storage media. The electronicstorages may include virtual storage resources (e.g., cloud storage, avirtual private network, and/or other virtual storage resources). Theelectronic storage may store software algorithms, information determinedby the processors, information obtained from servers, informationobtained from client devices, or other information that enables thefunctionality as described herein.

For example, in some embodiments, system 200 may represent a cloud basedsystem that includes multiple cloud-based components for providing asoftware development version control system for monitoring contributorperformance for source code programming projects. The cloud-based systemmay include components such as memory, control circuitry, and/or I/Ocircuitry. The cloud-based memory may be configured to store source codecontributions, from a plurality of software development tools, for afirst project, a first software development score for a firstcontributor, wherein the first software development score is based on afirst plurality of weighted metrics, and a plurality of other softwaredevelopment scores for other contributors. The cloud-based controlcircuitry may be configured to receive a first user input from the firstcontributor, retrieve a user profile for the first contributor inresponse to receiving the first user input, wherein the user profileincludes a first authorization, and determine a subset of the pluralityof other software development scores to which the first contributor hasaccess based on the first authorization. The cloud-based I/O circuitrymay be configured to generate for display, on a local display device, agraphical representation of a qualitative comparison of the firstsoftware development score and the subset of the plurality of othersoftware development scores.

In some embodiments, the cloud-based memory may be configured to storecurrent source code for a first project and tags for identified issuesin the current source code. The cloud-based control circuitry may beconfigured to receive a first contribution of source code for a firstproject to a software development version control system, wherein thefirst contribution is received from a first contributor, tag the firstcontribution with a first identified issue, assign the first identifiedissue to a second contributor, receive a second contribution of sourcecode to resolve the first identified issue, determine a first resolutiontype of the second contribution, and determine a first length ofprogramming time corresponding to the second contribution, generate afirst resolution metric for the second contribution based on the firstresolution type and the first length of programming time, wherein thefirst resolution metric is generated using a machine learning model thatcompares the first length of programming time to a determined averagelength of programming time for the first resolution type, and assign thefirst resolution metric to the first contributor. The cloud-based I/Ocircuitry may be configured to generate for display, on a local displaydevice, a first performance recommendation for the first contributor,wherein the first performance recommendation is based on comparing thefirst resolution metric to a first plurality of resolution metricsassigned to other contributors of the first project.

FIG. 2 also includes communication paths 228, 230, and 232.Communication paths 228, 230, and 232 may include the Internet, a mobilephone network, a mobile voice or data network (e.g., a 4G or LTEnetwork), a cable network, a public switched telephone network, or othertypes of communications network or combinations of communicationsnetworks. Communication paths 228, 230, and 232 may include one or morecommunications paths, such as a satellite path, a fiber-optic path, acable path, a path that supports Internet communications (e.g., IPTV),free-space connections (e.g., for broadcast or other wireless signals),or any other suitable wired or wireless communications path orcombination of such paths. The computing devices may include additionalcommunication paths linking a plurality of hardware, software, and/orfirmware components operating together. For example, the computingdevices may be implemented by a cloud of computing platforms operatingtogether as the computing devices.

As an example, with respect to FIG. 2 , machine learning model 202 maytake inputs 204 and provide outputs 206. The inputs may include multipledata sets such as a training data set and a test data set. Each of theplurality of data sets (e.g., inputs 204) may include data subsets withcommon characteristics. The common characteristics may includecharacteristics about a contributor, task and/or project for use indetermining resolution metrics, performance levels, and/or performancerecommendations. In some embodiments, outputs 206 may be fed back tomachine learning model 202 as input to train machine learning model 202(e.g., alone or in conjunction with user indications of the accuracy ofoutputs 206, labels associated with the inputs, or with other referencefeedback information). In another embodiment, machine learning model 202may update its configurations (e.g., weights, biases, or otherparameters) based on the assessment of its prediction (e.g., outputs206) and reference feedback information (e.g., user indication ofaccuracy, reference labels, or other information). In anotherembodiment, where machine learning model 202 is a neural network,connection weights may be adjusted to reconcile differences between theneural network's prediction and the reference feedback. In a further usecase, one or more neurons (or nodes) of the neural network may requirethat their respective errors are sent backward through the neuralnetwork to them to facilitate the update process (e.g., backpropagationof error). Updates to the connection weights may, for example, bereflective of the magnitude of error propagated backward after a forwardpass has been completed. In this way, for example, the machine learningmodel 202 may be trained to generate better predictions.

In some embodiments, machine learning model 202 may include anartificial neural network. In such embodiments, machine learning model202 may include input layer and one or more hidden layers. Each neuralunit of machine learning model 202 may be connected with many otherneural units of machine learning model 202. Such connections can beenforcing or inhibitory in their effect on the activation state ofconnected neural units. In some embodiments, each individual neural unitmay have a summation function which combines the values of all of itsinputs together. In some embodiments, each connection (or the neuralunit itself) may have a threshold function such that the signal mustsurpass before it propagates to other neural units. Machine learningmodel 202 may be self-learning and trained, rather than explicitlyprogrammed, and can perform significantly better in certain areas ofproblem solving, as compared to traditional computer programs. Duringtraining, an output layer of machine learning model 202 may correspondsto a classification of machine learning model 202 and an input known tocorrespond to that classification may be input into an input layer ofmachine learning model 202 during training. During testing, an inputwithout a known classification may be input into the input layer, and adetermined classification may be output.

In some embodiments, machine learning model 202 may include multiplelayers (e.g., where a signal path traverses from front layers to backlayers). In some embodiments, back propagation techniques may beutilized by machine learning model 202 where forward stimulation is usedto reset weights on the “front” neural units. In some embodiments,stimulation and inhibition for machine learning model 202 may be morefree flowing, with connections interacting in a more chaotic and complexfashion. During testing, an output layer of machine learning model 202may indicate whether or not a given input corresponds to aclassification of machine learning model 202 (e.g., determine a firstlength of programming time based on a determined average length ofprogramming time for a given first resolution type).

As shown in FIG. 2 , machine learning model 202 has generatedperformance metric 244, which is displayed on user device 224.Performance metric 244 may include an individual contributor'sperformance level (e.g., across multiple contributors and/or projects)or may indicate a latest performance metric. Additionally, performancemetric 242 is displayed on user device 222. Performance metric 242currently indicates the performance level of the entire project team.For example, performance metric 242 may indicate an aggregation onindividual performance metrics (e.g., as generated by process 300 (FIG.3 ) below).

FIG. 3 shows a flowchart of the steps involved in generating for displaya first performance recommendation for the first contributor, inaccordance with one or more embodiments. For example, process 300 mayrepresent the steps taken by one or more devices as shown in FIG. 1 whengenerating performance metric 244 (FIG. 2 ).

At step 302, process 300 receives (e.g., via a software developmentversion control system) a first contribution of source code for a firstproject to a software development version control system. For example,the first contribution may be received from a first contributor as partof a first project. In some embodiments, the system may alternatively oradditionally receive a contribution that third contribution is not asource code contribution. For example, the system may receive anadditional contribution for the first project from the firstcontributor, wherein the third contribution is not a source codecontribution, and wherein the first performance recommendation isfurther based on the third contribution.

At step 304, process 300 tags (e.g., via a software development versioncontrol system) the first contribution with a first identified issue.For example, the system may identify an issue automatically (e.g., basedon bug-tracking or automatic issued detection) or manually based on apeer review. The tags may include information (e.g., metadata)describing the identified issue.

At step 306, process 300 assigns (e.g., via a software developmentversion control system) the first identified issue to a secondcontributor. For example, the system may automatically assign theidentified issue to another contributor for peer review (e.g., asdescribed in FIG. 5 below). In some embodiments, the system may use amachine learning model (e.g., machine learning model 202 (FIG. 2 )) toprocess various information about the contributors, project, and issueto identify a contributor for assignment.

At step 308, process 300 receives (e.g., via a software developmentversion control system) a second contribution of source code to resolvethe first identified issue. For example, the second contribution ofsource code may include one or more edits to the first contributionand/or additional contributions to the first contributions that resolvethe issue. For example, the second contribution may include one or moreactions and/or modifications to the first contribution. Thesemodifications may include one or more different types of resolutions(e.g., fixing typographical errors, selecting a different algorithm,etc.). The system may track the different types of resolutions as wellas the time required for each resolution.

At step 310, process 300 determines (e.g., via a software developmentversion control system) a first resolution type of the secondcontribution. For example, the system may automatically detect theresolution type based on metadata associated with the firstcontribution. In some embodiments, the system may receive aclassification of the resolution type from the second contributor (e.g.,via user interface 100 (FIG. 1 )).

At step 312, process 300 determines (e.g., via a software developmentversion control system) a first length of programming time correspondingto the second contribution. For example, the system may track (e.g., viaa clock mechanism integrated into the software development versioncontrol system) the amount of programming time spent by the secondcontributor to resolve the issue. The system may use multiple means todetermine the length of programming time corresponding to the secondcontribution (e.g., using manual or automatic clock and timekeepermechanisms). Furthermore, as described in FIG. 1 above, in someembodiments, the system may divide the total time spent to generate thesecond contribution among the different resolution types (if any) aswell as time not spent generating the second contribution.

At step 314, process 300 generates (e.g., via a software developmentversion control system) a first resolution metric for the secondcontribution based on the first resolution type and the first length ofprogramming time. For example, the system may generate a quantitativeassessment of the amount of time and skill spent to resolve the issue.The system may use multiple factors to determine the resolution metricas described in FIG. 4 below.

At step 316, process 300 assigns (e.g., via a software developmentversion control system) the first resolution metric to the firstcontributor. For example, the system may modify a contributor profile ofthe first contributor to include the first resolution metric. Thecontributor profile may include information about the current andhistoric performance of the contributor and/or one or more resolutionmetrics assigned to the first contributor.

At step 318, process 300 generates for display (e.g., via a softwaredevelopment version control system) a first performance recommendationfor the first contributor. Accordingly, the system may use theprogramming time required to resolve the issue, the type of issue,and/or other characteristics of the contributor and the issue togenerate real-time recommendations related to the performance of thecontributor relative to the project team. The system may then displaythese recommendations in a user interface (e.g., user interface 100(FIG. 1 )) on a user device (e.g., user device 222 or 224 (FIG. 2 )).

For example, the first performance recommendation may be based oncomparing the first resolution metric to a first plurality of resolutionmetrics assigned to other contributors of the first project. Forexample, the system may determine a mean, median, mode, and/or otherstatistical difference or mathematical relationship of the firstresolution metric of the first contributor to the average resolutionmetrics of the other contributors. The system may then output thismetric (e.g., as a numerical expressed performance recommendation) ormay further modify this metric into a qualitative assessment of theperformance of the first contributor. The system may then include thisqualitative assessment in a media object that is displayed on userdevices (e.g., as shown in FIG. 2 ). Additionally or alternatively, thefirst performance recommendation may be based on determining a currentperformance level of the first contributor and determining an averageperformance level of the other contributors. The system may then comparethe current performance level of the first contributor to the averageperformance level of the other contributors.

In some embodiments, the performance recommendation is further based ondetermining a first number of contributions of first contributor to thefirst project without an identified issue. For example, the system mayaverage multiple resolution metrics associated with the firstcontributor. Additionally or alternatively, contributions with noidentified issues may be used in this average.

In some embodiments, generating the first performance recommendationfurther comprises comparing the first resolution metric to a secondplurality of resolution metrics assigned to other contributors of asecond project. For example, the system may retrieve resolution metricsof similar contributions of other contributors in order to determine theresolution metric. Alternatively or additionally, in some embodimentsthe system may generate the first resolution metric using a machinelearning model that compares the first length of programming time to adetermined average length of programming time for the first resolutiontype (e.g., as described in FIG. 2 above).

It is contemplated that the steps or descriptions of FIG. 3 may be usedwith any other embodiment of this disclosure. In addition, the steps anddescriptions described in relation to FIG. 3 may be done in alternativeorders or in parallel to further the purposes of this disclosure. Forexample, each of these steps may be performed in any order or inparallel or substantially simultaneously to reduce lag or increase thespeed of the system or method. Furthermore, it should be noted that anyof the devices or equipment discussed in relation to FIGS. 1-2 and 6-10could be used to perform one of more of the steps in FIG. 3 .

FIG. 4 shows a flowchart of the steps involved in determining aresolution metric, in accordance with one or more embodiments. Forexample, process 400 may represent the steps taken by one or moredevices as shown in FIGS. 1-2 and 6-10 when determining a resolutionmetric.

At step 402, process 400 retrieves (e.g., via a software developmentversion control system) a default resolution metric. For example, insome embodiments, the system may assign a default resolution metric toeach resolution type. Upon determining a resolution type and/or timerequired to resolve any issues, the system may input thesedeterminations into a lookup table databased that outputs a defaultresolution metric.

At step 404, process 400 determines (e.g., via a software developmentversion control system) whether or not to modify the default resolutionmetric based on a difference between contributor levels. For example,the system may determine a first contributor level of the firstcontributor, determine a second contributor level of the secondcontributor, and determine a difference between the first contributorlevel and the second contributor level. The system may then modify thefirst resolution metric based on the difference. The first contributorlevel may reflect a skill level or level of experience of the user.Accordingly, if second contributor has a high skill level and thus thetime to resolve the issue is low, the system can reflect this in thecalculation of the resolution metric.

If the system determines not to modify the default resolution metricbased on a difference between contributor levels, process 400 proceedsto step 410. For example, the system may determine that the differenceis not available (or undeterminable) based on a lack of informationabout the contributors. Alternatively or additionally, the system mayhave received a predetermined list of criteria (e.g., from the projectmanager) indicating the criteria to use for a resolution metric. Thesystem may determine that this criterion is not included. If the systemdetermines to modify the default resolution metric based on a differencebetween contributor levels, process 400 proceeds to step 406. At step406, process 400 determines (e.g., via a software development versioncontrol system) the difference between the contributor levels.

At step 408, process 400 modifies (e.g., via a software developmentversion control system) the default resolution metric before proceedingto step 410. At step 410, process 400 determines (e.g., via a softwaredevelopment version control system) whether or not to modify the defaultresolution metric based on difference between the number ofcontributions. For example, the system may determine a number ofcontributions to the first project of the first contributor during afirst time period, determine an average number of contributions by theother contributors to the first project, and determine a differencebetween the number of contributions and the average number ofcontributions. The system may then generate the first resolution metricbased on the difference. Accordingly, if the first contributor has ahigh level of contribution (e.g., indicative of the first contributorworking more than other contributors), the system can reflect this inthe calculation of the resolution metric.

If the system determines not to modify the default resolution metricbased on the difference between the number of contributions, process 400proceeds to step 416. For example, the system may determine that thedifference is not available (or undeterminable) based on a lack ofinformation about the contributors. Alternatively or additionally, thesystem may have received a predetermined list of criteria (e.g., fromthe project manager) indicating the criteria to use for a resolutionmetric. The system may determine that this criterion is not included.

If the system determines to modify the default resolution metric basedon the difference between the number of contributions, process 400proceeds to step 412. At step 412, process 400 determines (e.g., via asoftware development version control system) the difference between thenumber of contributions. At step 414, process 400 modifies (e.g., via asoftware development version control system) the default resolutionmetric before proceeding to step 416.

At step 416, process 400 determines (e.g., via a software developmentversion control system) whether or not to modify the default resolutionmetric based on a weight of the contribution. For example, in someembodiments, the system may modify the resolution metric based on aweight assigned to the contribution. The weight may be a quantitative orqualitative measure of the importance of a given contribution. Forexample, the weight may indicate that the contribution is particularlyimportant, therefore any issues with the contribution are more heavilyweighed against the contributor's resolution metric (and overallperformance metric and/or level). Additionally or alternatively, aproject manager may manually, or the system may automatically, weightthe contribution based on additional factors (e.g., the assigned user isattempting this type of contribution for the first time, thecontribution must be performed within a short turnaround time, etc.).

If the system determines not to modify the default resolution metricbased on the weight of the contribution, process 400 proceeds to step412. For example, the system may have received a predetermined list ofcriteria (e.g., from the project manager) indicating the criteria to usefor a resolution metric. The system may determine that this criterion isnot included. If the system determines to modify the default resolutionmetric based on the weight of the contribution, process 400 proceeds tostep 418. At step 418, process 400 determines (e.g., via a softwaredevelopment version control system) the weight of the contribution.

At step 420, process 400 modifies (e.g., via a software developmentversion control system) the default resolution metric before proceedingto step 422. For example, based on the modification the system mayoutput a resolution metric for use in determining a performance leveland/or performance recommendation of the first contributor.

It is contemplated that the steps or descriptions of FIG. 4 may be usedwith any other embodiment of this disclosure. In addition, the steps anddescriptions described in relation to FIG. 4 may be done in alternativeorders or in parallel to further the purposes of this disclosure. Forexample, each of these steps may be performed in any order or inparallel or substantially simultaneously to reduce lag or increase thespeed of the system or method. Furthermore, it should be noted that anyof the devices or equipment discussed in relation to FIGS. 1-2 and 6-10could be used to perform one of more of the steps in FIG. 4 .

FIG. 5 shows flowchart of the steps involved in assigning issues tocontributors based on current performance levels of the contributors, inaccordance with one or more embodiments. For example, process 500 mayrepresent the steps taken by one or more devices as shown in FIGS. 1-2when assigning issues to contributors.

At step 502, process 500 determines (e.g., via a software developmentversion control system) a current performance level of the firstcontributor. For example, the system may determine an individualperformance level (e.g., performance metric 244 (FIG. 2 ) as describedin FIG. 3 above. In some embodiments, the system may determine aperformance level based on a specific resolution metrics. For example,the system may determine specific resolution metrics that are relevantto a specific resolution type. After determining a resolution typeassociated with an identified issue, the system may determine resolutionmetrics that are relevant to the resolution type. The system may thenuse the relevant resolution metrics to assign the issue to acontributor. Accordingly, the system may assign peer review of an issueto a contributor that is particularly skilled in the relevant issue.

At step 504, process 500 determines (e.g., via a software developmentversion control system) an average performance level of the othercontributors. For example, the system may determine an individualperformance level (e.g., performance metric 244 (FIG. 2 ) as describedin FIG. 3 above for all other contributors on the project team. Thesystem may then average each of individual performance levels for thecontributors.

At step 506, process 500 compares (e.g., via a software developmentversion control system) the current performance level of the firstcontributor to the average performance level of the other contributors.For example, the system may determine a mean, median, mode, and/or otherstatistical difference or mathematical relationship of the currentperformance level of the first contributor to the average performancelevel of the other contributors.

At step 508, process 500 assigns (e.g., via a software developmentversion control system) an identified issue to the second contributor inresponse to determining that the current performance level of the secondcontributor exceeds the current performance level of the firstcontributor. For example, the system may assign issues (e.g., for peerreview) to a contributor after determining that that contributor has ahigher performance level than the contributor that created thecontribution.

It is contemplated that the steps or descriptions of FIG. 5 may be usedwith any other embodiment of this disclosure. In addition, the steps anddescriptions described in relation to FIG. 5 may be done in alternativeorders or in parallel to further the purposes of this disclosure. Forexample, each of these steps may be performed in any order or inparallel or substantially simultaneously to reduce lag or increase thespeed of the system or method. Furthermore, it should be noted that anyof the devices or equipment discussed in relation to FIGS. 1-2 and 6-10could be used to perform one or more of the steps in FIG. 5 .

FIG. 6 shows an illustrative user interface displaying a graphicalrepresentation of a software development score, in accordance with oneor more embodiments. For example, user interface 600 may be generatedfor display on user device 222 (FIG. 2 ) using one or more components ofsystem 200 (FIG. 2 ).

User interface 600 includes a qualitative software development score.The score is represented in a plurality of manners such as numericalrepresentation 602, graphical representation 604, and textualrepresentation 606. It should be noted that the qualitative softwaredevelopment score may be expressed in any manner that relates to and/oris measured by the quality of the contributor's contributions ratherthan their quantity.

In some embodiments, the system may provide multiple expressions of thequalitative software development score. The expression selected and/orthe arrangement of the expressions may be dynamically selected based oninformation in a user profile.

For example, a system may receive a first plurality of quantitativesoftware development metrics. For example, the system may receivequantitative software development metrics (e.g., as shown in FIG. 10 ),which relate to and/or measured by the quantity of the contributor'scontributions rather than their quality.

The system may then apply a respective weight to each of the firstplurality of quantitative software development metrics to generate thefirst plurality of weighted metrics. For example, the system may receivea weight specified by a contributor, a project team management, aninstitution that establishes weights for given metrics. In someembodiments, the system may use a machine learning model (e.g., machinelearning model 202 (FIG. 2 )) to select weights.

For example, the system may retrieve data on contributors having a knownstrong performance and the metrics related to those contributors. Thesystem may then apply a machine learning model to select weights for thevarious metrics such that a score based on the plurality of weightedmetrics has the highest likelihood of indicating a strong performance.

After applying the respective weights, the system may then calculate thefirst software development score based on the first plurality ofweighted metrics. In some embodiments, the weighted development scoremay be based on the algorithm below where “W” corresponds to a weightand “m” corresponds to a given quantitative software development metric.

$f = {{100*{\sum\limits_{j_{}}^{}{\ln\left( {W_{1}*{\underline{m}}_{1}} \right)}}} + {\ln\left( {W_{2}*{\underline{m}}_{2}} \right)\ldots\ln\left( {W_{j}*{\underline{m}}_{j}} \right)}}$

FIG. 7 shows an illustrative user interface displaying a graphicalrepresentation of a software development score corresponding tocontribution categories, in accordance with one or more embodiments. Forexample, user interface 700 may be generated for display on user device222 (FIG. 2 ) using one or more components of system 200 (FIG. 2 ). Forexample, in addition to recording quantitative software developmentmetrics for a plurality of contributors and from a plurality of softwaredevelopment tools in order to generate a software development score, thesystem may also store information about a type of contribution.

For example, the system may store information such as a contributioncategory. In some embodiments, a contribution category may include thediversity of the contributions, the value on individual contributions,the number of specific actions (e.g., pull requests), and/or assessmentsof the quality of code. For example, the system may create categoriesbased on any characteristic that may distinguish one category fromanother.

The system may further categorize a plurality of weighted (orunweighted) metrics prior to creating the qualitative softwaredevelopment score. For example, the system may create differentqualitative software development scores for various categories. Thesystem may then generate graphical representations of these scores anddisplay them together (e.g., as shown in FIG. 7 ).

For example, the system may generate for display a first categoricalqualitative software development score (e.g., score 702) along with asecond categorical qualitative software development score (e.g., score704). As described in FIG. 6 , the system may provide a variety ofaudio/visual and/or textual cues to indicate the qualitive nature ofeach score. For example, as shown in FIG. 7 , user interface 700 mayinclude bar graphs, color variations, numerical assessments, and textualdescriptions to provide an intuitive user interface.

FIG. 8 shows an illustrative user interface displaying graphicalrepresentations of a plurality of software development scores forrespective users, in accordance with one or more embodiments. Forexample, user interface 800 may be generated for display on user device222 (FIG. 2 ) using one or more components of system 200 (FIG. 2 ).

For example, in some embodiments, the system may determine that acontributor or project manager may have access to a plurality of othercontributors' software development scores as well as additionalinformation. For example, the user profile of the contributor mayindicate that the contributor has access to qualitative comparison of afirst software development score and other software development scores,individual software development scores for other users, categoricalbreakdowns of individual software development scores for other users,and/or software development metrics of one or more users.

For example, as shown in user interface 800, the system has generatedindividual report 802 and individual report 804. The contributor mayaccess these individual reports and view information about the current,historical, and/or future extrapolated software development scoreprojections for a selected contributor. For example, the system mayreceive a user input, and in response to the user input, generate fordisplay a list of a plurality of quantitative software developmentmetrics and/or scores. These metrics and/or scores may be furtherselectable to review the identities of individual contributors as wellas information about the individual contributors. The information thatis accessible may be filtered by the system based on the authorizationof the contributor accessing the information and/or the contributor forwhom information about is being accessed.

FIG. 9 shows an illustrative user interface displaying graphicalrepresentation of a qualitative comparison of a first softwaredevelopment score and other software development scores, in accordancewith one or more embodiments. For example, user interface 900 may begenerated for display on user device 222 (FIG. 2 ) using one or morecomponents of system 200 (FIG. 2 ).

For example, the system may generate for display, on a local device(e.g., user device 222 (FIG. 2 )), a graphical representation of aqualitative comparison of the first software development score and asubset of a plurality of other software development scores. As shown inFIG. 9 , the comparison may include information on the title, identity,and/or other categorical breakdown of the contributors. In such afashion, a contributor may assess his/her performance based on theperformance of other contributors in a similar category (e.g., jobtitle, seniority, pay level, etc.). For example, graphic 902 may show afirst contributor's performance among other contributors sharing thesame job title, whereas graphic 904 may show a second contributor'sperformance among other contributors sharing the same job title.

For example, the system may determine a contributor category for acontributor and filter a subset of the plurality of other softwaredevelopment scores for software development scores corresponding tocontributors in the contributor category. For example, the system mayfilter the software development scores for contributors having a commonseniority and/or job title.

The system may then generate for display a graphical representation of aqualitative comparison of the first software development score and thefiltered subset of the plurality of other software development scores.The recommendations may include recommendations for future projectsand/or tasks as well as recommendation on a contributor's performance.For example user interface 900 may display a software development scoreusing graphical elements to display whether or not the contributor isperforming above or below an average for a given category ofcontributors.

FIG. 10 shows an illustrative pseudocode for generating softwaredevelopment scores, in accordance with one or more embodiments. Forexample, user interface 1000 may show exemplary source code for asoftware development version control system that monitors contributorperformance for source code programming projects. For example, userinterface 1000 may be generated for display on user device 222 (FIG. 2 )using one or more components of system 200 (FIG. 2 ).

As shown in user interface 1000, the system has generated a plurality ofquantitative software development metrics. For example, the system maygenerate these metrics by analyzing contributions from a first softwaredevelopment tool. The system may then iteratively update the pluralityof quantitative software development metrics as issues are detected withthe contribution. For example, in response to detecting that acontributor has committed an additional contribution to the system, thesystem may include the metric corresponding to committed contributionsby one.

In some embodiments, the system may monitor numerous metrics. Themetrics may include the number, quality, or predetermined value ofvarious metrics. In some embodiments, the system may determine themetrics in real-time and update the metrics accordingly. For example,the system may receive a contribution committed to the softwaredevelopment version control system from a contributor and update themetric of the contributor iteratively. Illustrative metrics may includea number, quality, or predetermined value of contributions, includingadditions, deletions, removals, renames, and/or modification submittedto the system and/or applied to contributions.

In some embodiments, the system may further generate metrics as arelation to a time period, contribution category, and/or contributorcategory. For example, the system may track average weekly contributionsto the software development version control system. The system may trackcontributions of a given type as well as be a category of contributors.In some embodiments, the system may further compare contributions toother contributions. For example, the system may determine how uniqueand/or distinct a given project contributions is. Additionally oralternative, the system may generate one or more statistics for thecontribution (e.g., length, average number of issues, etc.).

The system may track these metrics as shown by metrics 1002 in userinterface 1000. Furthermore, the system may track the metrics forindividual users in order to generate software development scores forindividual contributors (e.g., score 1004).

FIG. 11 shows a flowchart of the steps involved in generating fordisplay a graphical representation of a qualitative comparison of afirst software development score and a subset of the plurality of othersoftware development scores, in accordance with one or more embodiments.For example, process 1200 provides one embodiment of how to generate thesoftware development score featuring numerical representation 602 (FIG.6 ).

At step 1102, process 1100 receives (e.g., via a software developmentversion control system) a first software development score for a firstcontributor to a software development version control system. Forexample, the first software development score may be based on a firstplurality of weighted metrics. In some embodiments, the system mayreceive a first plurality of quantitative software development metrics.The system may then apply a respective weight to each of the firstplurality of quantitative software development metrics to generate thefirst plurality of weighted metrics, and the system may then calculatethe first software development score based on the first plurality ofweighted metrics.

At step 1104, process 1100 stores (e.g., in database of system 200 (FIG.2 )) the first software development score with a plurality of othersoftware development scores for other contributors. At step 1106,process 1100 receives (e.g., via a software development version controlsystem) a first user input from the first contributor. For example, thefirst user input may be a user input requesting access to a databasewith a plurality of software development score and/or a user inputrequesting access to user interface 600 (FIG. 6 )).

At step 1108, process 1100 retrieves (e.g., via a software developmentversion control system) a user profile for the first contributor. Forexample, the user profile may be stored by the system and haveinformation related to the user. For example, the user profile mayinclude a first authorization in response to receiving the first userinput.

At step 1110, process 1100 determines (e.g., via a software developmentversion control system) a subset of the plurality of other softwaredevelopment scores to which the first contributor has access based onthe first authorization. For example, in order to preserve privacy ofcontributors, the system may generate comparisons based on anauthorization level of a contributor requesting access. Accordingly, insome embodiments, the system may first determine the plurality of scores(e.g., corresponding to a plurality of other contributors) to which thecontributor requesting access is authorized to access.

At step 1112, process 1100 generates for display (e.g., on a localdevice such as user device 222 (FIG. 2 )) a graphical representation ofa qualitative comparison of the first software development score and thesubset of the plurality of other software development scores (e.g., asshown in FIG. 9 ). For example, the system may also receive a secondsoftware development score for a second contributor to the softwaredevelopment version control system, wherein the second softwaredevelopment score is based on a second plurality of weighted metrics.The system may then determine the first contributor has access to thesecond software development score based on the first authorization. Thesystem may then generate for display a graphical representation of thesecond software development score and/or generate for display agraphical representation of a qualitative comparison of the firstsoftware development score and the second software development score.

It is contemplated that the steps or descriptions of FIG. 11 may be usedwith any other embodiment of this disclosure. In addition, the steps anddescriptions described in relation to FIG. 11 may be done in alternativeorders or in parallel to further the purposes of this disclosure. Forexample, each of these steps may be performed in any order or inparallel or substantially simultaneously to reduce lag or increase thespeed of the system or method. Furthermore, it should be noted that anyof the devices or equipment discussed in relation to FIGS. 1-2 and 6-10could be used to perform one or more of the steps in FIG. 11 .

FIG. 12 shows a flowchart of the steps involved in calculating asoftware development score based on a plurality of weighted metrics, inaccordance with one or more embodiments. For example, process 1200provides one embodiment of how to generate the software developmentscore featuring numerical representation 602 (FIG. 6 ).

At step 1202, process 1200 receives (e.g., via a software developmentversion control system) a contribution of source code from a softwaredevelopment tool. For example, the system may receive a contributorsubmission of a contribution. The software development version controlsystem may store and track these contributions as well as update aproject management tool (e.g., as described in FIG. 1 ).

At step 1204, process 1200 detects (e.g., via a software developmentversion control system) an issue in the first contribution. For example,the system may identify an issue automatically (e.g., based onbug-tracking or automatic issued detection) or manually based on a peerreview. The tags may include information (e.g., metadata) describing theidentified issue.

At step 1206, process 1200 generates (e.g., via a software developmentversion control system) a plurality of quantitative software developmentmetrics based on the issue. For example, in some embodiments, thesoftware development metrics may include metrics relating tocontributions committed to the software development version controlsystem, unique additions to the software development version controlsystem, deletions submitted to the software development version controlsystem, unique contributions added to the software development versioncontrol system, average weekly contributions to the software developmentversion control system, distinct project contributions to the softwaredevelopment version control system, distinct organization contributionsto the software development version control system, contributionstatistics, number of contribution modifications submitted to thesoftware development version control system, number of contributionsadded to the software development version control system, number ofcontributions removed from the software development version controlsystem, number of contributions renamed at the software developmentversion control system, or number of positive reviews of contributions.These metrics may be expressed in a quantitative fashion (e.g., a numbercontributions committed). Alternatively or additionally, the metrics maybe expressed in a qualitative fashion (e.g., “above average”, “average”,“below average”, “good”, “bad”, etc.).

At step 1208, process 1200 applies (e.g., via a software developmentversion control system) a respective weight to each of the plurality ofquantitative software development metrics to generate a plurality ofweighted metrics. The weight may be a quantitative or qualitativemeasure of the importance of a given metric. For example, the weight mayindicate that the metric is particularly important therefore any issueswith the contribution are more heavily weighed against the contributor'sresolution metric (and overall performance metric and/or level).Additionally or alternatively, a project manager may manually, or thesystem may automatically, weight the contribution based on additionalfactors (e.g., the assigned user is attempting this type of contributionfor the first time, the contribution must be performed within a shortturnaround time, etc.).

At step 1210, process 1200 calculates (e.g., via a software developmentversion control system) a software development score based on theplurality of weighted metrics. For example, the system may use one ormore algorithms featuring one or more of the of development scores. Insome embodiments, the system may use a weighted average as described inrelation to FIG. 6 .

It is contemplated that the steps or descriptions of FIG. 12 may be usedwith any other embodiment of this disclosure. In addition, the steps anddescriptions described in relation to FIG. 12 may be done in alternativeorders or in parallel to further the purposes of this disclosure. Forexample, each of these steps may be performed in any order or inparallel or substantially simultaneously to reduce lag or increase thespeed of the system or method. Furthermore, it should be noted that anyof the devices or equipment discussed in relation to FIGS. 1-2 and 6-10could be used to perform one or more of the steps in FIG. 12 .

The above-described embodiments of the present disclosure are presentedfor purposes of illustration and not of limitation, and the presentdisclosure is limited only by the claims which follow. Furthermore, itshould be noted that the features and limitations described in any oneembodiment may be applied to any other embodiment herein, and flowchartsor examples relating to one embodiment may be combined with any otherembodiment in a suitable manner, done in different orders, or done inparallel. In addition, the systems and methods described herein may beperformed in real time. It should also be noted that the systems and/ormethods described above may be applied to, or used in accordance with,other systems and/or methods.

The present techniques will be better understood with reference to thefollowing enumerated embodiments:

-   -   1. A method of monitoring contributor performance in software        development version control systems, the method comprising:        receiving a first contribution of source code for a first        project to a software development version control system,        wherein the first contribution is received from a first        contributor; tagging the first contribution with a first        identified issue; assigning the first identified issue to a        second contributor; receiving a second contribution of source        code to resolve the first identified issue; determining a first        resolution type of the second contribution; determining a first        length of programming time corresponding to the second        contribution; generating a first resolution metric for the        second contribution based on the first resolution type and the        first length of programming time; assigning the first resolution        metric to the first contributor; and generating for display a        first performance recommendation for the first contributor,        wherein the first performance recommendation is based on        comparing the first resolution metric to a first plurality of        resolution metrics assigned to other contributors of the first        project.    -   2. The method of embodiment 1, wherein the first performance        recommendation is further based on determining a first number of        contributions of first contributor to the first project without        an identified issue.    -   3. The method of embodiment 1 or 2, wherein generating the first        resolution metric further comprises: determining a first        contributor level of the first contributor; determining a second        contributor level of the second contributor; and determining a        difference between the first contributor level and the second        contributor level, wherein the first resolution metric is        further based on the difference.    -   4. The method of any one of embodiments 1-3, wherein generating        the first resolution metric further comprises: determining a        number of contributions to the first project of the first        contributor during a first time period; determining an average        number of contributions by the other contributors to the first        project; and determining a difference between the number of        contributions and the average number of contributions, wherein        the first resolution metric is further based on the difference.    -   5. The method of any one of embodiments 1-4, wherein generating        the first resolution metric further comprises: determining a        first weight for the first contribution, wherein the first        weight is assigned by a manager of the first project, wherein        the first resolution metric is further based on the first        weight.    -   6. The method of any one of embodiments 1-5, wherein generating        the first performance recommendation further comprises comparing        the first resolution metric to a second plurality of resolution        metrics assigned to other contributors of a second project.    -   7. The method of any one of embodiments 1-6, wherein the first        resolution metric is generated using a machine learning model        that compares the first length of programming time to a        determined average length of programming time for the first        resolution type.    -   8. The method of any one of embodiments 1-7, further comprising        receiving a third contribution for the first project from the        first contributor, wherein the third contribution is not a        source code contribution, and wherein the first performance        recommendation is further based on the third contribution.    -   9. The method of any one of embodiments 8, wherein the first        performance recommendation is further based on: determining a        current performance level of the first contributor; determining        an average performance level of the other contributors; and        comparing the current performance level of the first contributor        to the average performance level of the other contributors.    -   10. The method of any one of embodiments 1-9, wherein assigning        the first identified issue to the second contributor comprises:        determining a current performance level of the first        contributor; determining a current performance level of the        second contributor; comparing the current performance level of        the first contributor to the current performance level of the        second contributor; and assigning the first identified issue to        the second contributor in response to determining that the        current performance level of the second contributor exceeds the        current performance level of the first contributor.    -   11. A method of monitoring contributor performance in software        development version control systems, the method comprising:        receiving, using control circuitry, a first software development        score for a first contributor to a software development version        control system, wherein the first software development score is        based on a first plurality of weighted metrics; storing, in a        database, the first software development score with a plurality        of other software development scores for other contributors;        receiving, using the control circuitry, a first user input from        the first contributor requesting access to the database; in        response to receiving the first user input, retrieving, using        the control circuitry, a user profile for the first contributor,        wherein the user profile includes a first authorization;        determining, using the control circuitry, a subset of the        plurality of other software development scores to which the        first contributor has access to based on the first        authorization; and generating for display, on a local device, a        graphical representation of a qualitative comparison of the        first software development score and the subset of the plurality        of other software development scores.    -   12. The method of embodiment 11, further comprising: receiving a        first plurality of quantitative software development metrics;        applying a respective weight to each of the first plurality of        quantitative software development metrics to generate the first        plurality of weighted metrics; and calculating the first        software development score based on the first plurality of        weighted metrics.    -   13. The method of embodiment 12, further comprising: determining        a subset of the first plurality of quantitative software        development metrics corresponding to a first contribution        category; and generating for display a graphical representation        of a qualitative assessment of the subset of the first plurality        of quantitative software development metrics corresponding to a        first contribution category.    -   14. The method of embodiment 12 or 13, wherein the first        plurality of quantitative software development metrics include        metrics relating to contributions committed to the software        development version control system, unique additions to the        software development version control system, deletions submitted        to the software development version control system, unique        contributions added to the software development version control        system, average weekly contributions to the software development        version control system, distinct project contributions to the        software development version control system, distinct        organization contributions to the software development version        control system, contribution statistics, number of contribution        modifications submitted to the software development version        control system, number of contributions added to the software        development version control system, number of contributions        removed from the software development version control system,        number of contributions renamed at the software development        version control system, or number of positive reviews of        contributions.    -   15. The method of anyone of embodiments 12-14, further        comprising: receiving a first contribution of source code from a        first software development tool; detecting an issue in the first        contribution; and generating the first plurality of quantitative        software development metrics based on the issue.    -   16. The method of anyone of embodiments 11-15, further        comprising: receiving a second software development score for a        second contributor to the software development version control        system, wherein the second software development score is based        on a second plurality of weighted metrics; determining the first        contributor has access to the second software development score        based on the first authorization; and generating for display a        graphical representation of the second software development        score.    -   17. The method of anyone of embodiments 11-16, further        comprising: receiving a second user input; in response to the        second user input, generating for display a list of the first        plurality of quantitative software development metrics.    -   18. The method of anyone of embodiments 11-17, further        comprising: determining a contributor category for the first        contributor; filtering the subset of the plurality of other        software development scores for software development scores        correspond to contributors in the contributor category; and        generating for display a graphical representation of a        qualitative comparison of the first software development score        and the filtered subset of the plurality of other software        development scores.    -   19. The method of anyone of embodiments 11-18, further        comprising: receiving an updated first software development        score for the first contributor; storing, in the database, the        updated first software development score; and generating for        display a graphical representation of a relationship of the        first software development score to the updated first software        development score.    -   20. The method of embodiment 19, further comprising:        extrapolating a future first software development score for the        first contributor on a future project based on the first        software development score and the updated first software        development score; and generating for display a recommendation        for staffing the future project based on the future first        software development score.    -   21. A tangible, non-transitory, machine-readable medium storing        instructions that, when executed by a data processing apparatus,        cause the data processing apparatus to perform operations        comprising those of any of embodiments 1-20.    -   22. A system comprising: one or more processors; and memory        storing instructions that, when executed by the processors,        cause the processors to effectuate operations comprising those        of any of embodiments 1-20.    -   23. A system comprising means for performing any of embodiments        1-20.

What is claimed is:
 1. A software development version control system formonitoring contributions to software development version control systemsfor source code programming projects, comprising: cloud-based memoryconfigured to: store source code contributions, from a plurality ofsoftware development tools, for a first project; and store a pluralityof software development scores for contributors; cloud-based controlcircuitry configured to: receive a first user input from a first user;retrieve a user profile for the first user in response to receiving thefirst user input, wherein the user profile includes a firstauthorization; determine a subset of the plurality of softwaredevelopment scores to which the first user has access to based on thefirst authorization; and cloud-based I/O circuitry configured togenerate for display, on a local display device, a graphicalrepresentation of a qualitative comparison of the subset of theplurality of software development scores.
 2. A method for monitoringcontributions to software development version control systems for sourcecode programming projects, comprising: storing, in a database, aplurality of software development scores for contributors to a softwaredevelopment version control system, wherein each software developmentscore of the plurality of software development scores is based on aplurality of weighted metrics; receiving a first user input from a firstuser requesting access to the database; in response to receiving thefirst user input, retrieving a user profile for the first user, whereinthe user profile includes a first authorization; determining a subset ofthe plurality of software development scores to which the first user hasaccess to based on the first authorization; and generating for display,on a local device, a graphical representation of a qualitativecomparison the subset of the plurality of software development scores.3. The method of claim 2, further comprising: receiving a firstplurality of quantitative software development metrics; applying arespective weight to each of the first plurality of quantitativesoftware development metrics to generate the plurality of weightedmetrics; and calculating a first software development score of theplurality of software development scores based on the plurality ofweighted metrics.
 4. The method of claim 3, further comprising:determining a subset of the first plurality of quantitative softwaredevelopment metrics corresponding to a first contribution category; andgenerating for display a graphical representation of a qualitativeassessment of the subset of the first plurality of quantitative softwaredevelopment metrics corresponding to a first contribution category. 5.The method of claim 3, wherein the first plurality of quantitativesoftware development metrics include metrics relating to contributionscommitted to the software development version control system, uniqueadditions to the software development version control system, deletionssubmitted to the software development version control system, uniquecontributions added to the software development version control system,average weekly contributions to the software development version controlsystem, distinct project contributions to the software developmentversion control system, distinct organization contributions to thesoftware development version control system, contribution statistics,number of contribution modifications submitted to the softwaredevelopment version control system, number of contributions added to thesoftware development version control system, number of contributionsremoved from the software development version control system, number ofcontributions renamed at the software development version controlsystem, or number of positive reviews of contributions.
 6. The method ofclaim 3, further comprising: receiving a first contribution of sourcecode from a first software development tool; detecting an issue in thefirst contribution; and generating the first plurality of quantitativesoftware development metrics based on the issue.
 7. The method of claim2, further comprising: receiving a second software development score fora second user to the software development version control system,wherein the second software development score is based on a secondplurality of weighted metrics; determining the first user has access tothe second software development score based on the first authorization;and generating for display a graphical representation of the secondsoftware development score.
 8. The method of claim 3, furthercomprising: receiving a second user input; in response to the seconduser input, generating for display a list of the first plurality ofquantitative software development metrics.
 9. The method of claim 2,further comprising: determining a contributor category for the firstuser; filtering the subset of the plurality of software developmentscores for software development scores correspond to contributors in thecontributor category; and generating for display a graphicalrepresentation of a qualitative comparison of a first softwaredevelopment score and the filtered subset of the plurality of softwaredevelopment scores.
 10. The method of claim 2, further comprising:receiving an updated first software development score for a contributor;storing, in the database, the updated first software development score;and generating for display a graphical representation of a relationshipof a first software development score to the updated first softwaredevelopment score.
 11. The method of claim 10, further comprising:extrapolating a future first software development score for a firstcontributor on a future project based on a first software developmentscore and the updated first software development score; and generatingfor display a recommendation for staffing the future project based onthe future first software development score.
 12. A non-transitorycomputer-readable medium comprising instructions that, when executed byone or more processors, cause operations comprising: storing, in adatabase, with a plurality of software development scores forcontributors to a software development version control system, whereineach software development score of the plurality of software developmentscores is based on a plurality of weighted metrics; receiving a firstuser input from a first user requesting access to the database;retrieving a user profile for a first user in response to receiving thefirst user input, wherein the user profile includes a firstauthorization; determining a subset of the plurality of softwaredevelopment scores to which the first user has access to based on thefirst authorization; and generating for display a graphicalrepresentation of a qualitative comparison of the subset of theplurality of software development scores.
 13. The non-transitorycomputer-readable medium of claim 12, wherein the instructions furthercause operations comprising: receiving a first plurality of quantitativesoftware development metrics; applying a respective weight to each ofthe first plurality of quantitative software development metrics togenerate the plurality of weighted metrics; and calculating a firstsoftware development score of the plurality of software developmentscores based on the plurality of weighted metrics.
 14. Thenon-transitory computer-readable medium of claim 13, wherein theinstructions further cause operations comprising: determining a subsetof the first plurality of quantitative software development metricscorresponding to a first contribution category; generating for display agraphical representation of a qualitative assessment of the subset ofthe first plurality of quantitative software development metricscorresponding to a first contribution category.
 15. The non-transitorycomputer-readable medium of claim 13, wherein the instructions furthercause operations comprising: receiving a first contribution of sourcecode from a first software development tool; detecting an issue in thefirst contribution; and generating the first plurality of quantitativesoftware development metrics based on the issue.
 16. The non-transitorycomputer-readable medium of claim 12, wherein the instructions furthercause operations comprising: receiving a second software developmentscore for a second user to the software development version controlsystem, wherein the second software development score is based on asecond plurality of weighted metrics; determining the first user hasaccess to the second software development score based on the firstauthorization; and generating for display a graphical representation ofthe second software development score.
 17. The non-transitorycomputer-readable medium of claim 13, wherein the instructions furthercause operations comprising: receiving a second user input; in responseto the second user input, generating for display a list of the firstplurality of quantitative software development metrics.
 18. Thenon-transitory computer-readable medium of claim 12, wherein theinstructions further cause operations comprising: determining acontributor category for the first user; filtering the subset of theplurality of software development scores for software development scorescorrespond to contributors in the contributor category; and generatingfor display a graphical representation of a qualitative comparison of afirst software development score and the filtered subset of theplurality of software development scores.
 19. The non-transitorycomputer-readable medium of claim 12, wherein the instructions furthercause operations comprising: receiving an updated first softwaredevelopment score for a contributor; storing, in the database, theupdated first software development score; and generating for display agraphical representation of a relationship of a first softwaredevelopment score to the updated first software development score. 20.The non-transitory computer-readable medium of claim 19, wherein theinstructions further cause operations comprising: extrapolating a futurefirst software development score for a first contributor on a futureproject based on a first software development score and the updatedfirst software development score; and generating for display arecommendation for staffing the future project based on the future firstsoftware development score.